Thank you for the PR!

Great idea! I would definitely apply that.
I also asked a question about test cases in the issue's thread. Please check it out.

The problem here is that the code should be implemented in this way:

object extract extends ExtractSyntax

trait ExtractSyntax {
  implicit def toExtractOps[F[_], A](fa: F[A]): ExtractOps[F, A] = new ExtractOps[F, A](fa)
}

final class ExtractOps[F[_], A](private val fa: F[A]) extends AnyVal {
  def extract(implicit ev: Extract[F]): A = ev.extract(fa)
}

Doesn't this break the limitations of using value classes? I mean passing type arguments to ExtractOps and the new ExtractOps[F, A](fa) all will result in unintended boxing, right?

@aluscent ,
sorry for the long reply.

Doesn't this break the limitations of using value classes? I mean passing type arguments to ExtractOps and the new ExtractOpsF, A all will result in unintended boxing, right?

To be honest, I'm not sure I'm totally getting your concern. Why do you think the above should cause the boxing, could you elaborate please? To my best knowledge, no it shouldn't in this case. But I might be missing something. So do not take my word for it :)

If you're in doubt, you can check it for yourself by decompiling scala code to java (there are a plenty of open-source tools available) and see what it looks like. I did it a few times for some other typeclasses and AnyVal worked out pretty good there (i.e. no extra allocation/boxing whatsoever), but those might not be exactly the same case as this one.

Dear @satorg, I also have to apologize for answering so late. I was busy bringing up a campaign and in the meantime, I was checking the decompiled code to see if the boxing occurs.
This is the closest I could've get to the code you mentioned (to avoid boxing):

object extract extends ExtractSyntax

trait ExtractSyntax {
  implicit final def catsSyntaxExtract[F[_], A](fa: F[A]): ExtractOps[F, A] = new ExtractOps[F, A](fa)
}

final class ExtractOps[F[_], A](private val fa: F[A]) extends AnyVal {
  def extract(implicit F: Extract[F]): A = F.extract(fa)
}

This piece of code while preserving the implicit ExtractOps, makes it a value class.
Although the efforts, boxing was inevitable in any way I tried. I put the decompiled code down below. Here's the code belonging to extract.class:

public final class extract {
    public static Object catsSyntaxExtract(final Object fa) {
        return extract$.MODULE$.catsSyntaxExtract(fa);
    }
}

public final class extract$ implements ExtractSyntax {
    public static final extract$ MODULE$ = new extract$();

    static {
        ExtractSyntax.$init$(MODULE$);
    }

    public final <F, A> F catsSyntaxExtract(final F fa) {
        return ExtractSyntax.catsSyntaxExtract$(this, fa);
    }

    private extract$() {
    }
}

And the code for ExtractSyntax.class:

public interface ExtractSyntax {
    // $FF: synthetic method
    static Object catsSyntaxExtract$(final ExtractSyntax $this, final Object fa) {
        return $this.catsSyntaxExtract(fa);
    }

    default <F, A> F catsSyntaxExtract(final F fa) {
        return fa;
    }

    static void $init$(final ExtractSyntax $this) {
    }
}

Also the code for ExtractOps.class:

public final class ExtractOps<F, A> {
   private final F alleycats$syntax$ExtractOps$$fa;

   public static <F, A> boolean equals$extension(final F $this, final Object x$1) {
      return .MODULE$.equals$extension($this, x$1);
   }

   public static <F, A> int hashCode$extension(final F $this) {
      return .MODULE$.hashCode$extension($this);
   }

   public static <F, A> A extract$extension(final F $this, final Extract<F> F) {
      return .MODULE$.extract$extension($this, F);
   }

   public F alleycats$syntax$ExtractOps$$fa() {
      return this.alleycats$syntax$ExtractOps$$fa;
   }

   public A extract(final Extract<F> F) {
      return .MODULE$.extract$extension(this.alleycats$syntax$ExtractOps$$fa(), F);
   }

   public int hashCode() {
      return .MODULE$.hashCode$extension(this.alleycats$syntax$ExtractOps$$fa());
   }

   public boolean equals(final Object x$1) {
      return .MODULE$.equals$extension(this.alleycats$syntax$ExtractOps$$fa(), x$1);
   }

   public ExtractOps(final F fa) {
      this.alleycats$syntax$ExtractOps$$fa = fa;
   }
}

public final class ExtractOps$ {
   public static final ExtractOps$ MODULE$ = new ExtractOps$();

   public final <F, A> A extract$extension(final F $this, final Extract<F> F) {
      return F.extract($this);
   }

   public final <F, A> int hashCode$extension(final F $this) {
      return $this.hashCode();
   }

   public final <F, A> boolean equals$extension(final F $this, final Object x$1) {
      boolean var10000;
      if (x$1 instanceof ExtractOps) {
         Object var5 = x$1 == null ? null : ((ExtractOps)x$1).alleycats$syntax$ExtractOps$$fa();
         if (BoxesRunTime.equals($this, var5)) {
            var10000 = true;
            return var10000;
         }
      }

      var10000 = false;
      return var10000;
   }

   private ExtractOps$() {
   }
}

Now with my knowledge of Java, this code results in boxing in several points:

• The class ExtractOps[F, A] is defined as a value class (extends AnyVal) in Scala, but due to its generic nature (F), the JVM cannot avoid boxing in certain cases. Generics in the JVM are erased at runtime, so ExtractOps[F, A] is effectively treated as an Object, forcing the JVM to allocate an instance.
• Methods like extract in ExtractOps are compiled into extension methods within the ExtractOps$ singleton. These methods operate on the wrapped value (fa), and because $this is generic, boxing occurs whenever F is instantiated as a primitive type.

And many other points.

I am studying and trying to find ways to make sure, and this comment is for updating you and the team. Please let me know if you know better ways to make sure.

@aluscent , thank you for the incredible research!

Did you try to make a call to the 'extract' extension, decompile it, and find out what the code looks like at the call site?

The fact that compiler generates ExtractOps class and other stuff does not tell exactly that it will be instantiated in every case.